{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "MVNN_training.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/AyushGupta51379/COMP_5331_Project_Fake_News_Detection/blob/master/MVNN_training_validation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ghzNr1TklPAR"
      },
      "source": [
        "# MVNN\n",
        "\n",
        "This piece of work is an implementation of Multi-domain Visual Neural Network (MVNN), which is first proposed in the paper [Exploiting Multi-domain Visual Information for Fake News Detection](https://arxiv.org/abs/1908.04472)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vYmmpTvxlII9"
      },
      "source": [
        "# some basic things to include\n",
        "import os\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "from torchvision import datasets, transforms\n",
        "\n",
        "from PIL import Image\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.image as mpimg\n",
        "\n",
        "# some preprocessing techniques\n",
        "from scipy.fftpack import dct\n",
        "\n",
        "# custom dataset\n",
        "from torch.utils.data.dataset import Dataset\n",
        "\n",
        "# this is only required for Google Colab\n",
        "from google.colab import drive\n",
        "\n",
        "import time\n",
        "from datetime import datetime\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HsuzqnBVpuAR"
      },
      "source": [
        "these modules and dataset require to be downloaded (unless they are executed under a repository)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iCbaTVoCPyWo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0657dcc7-301e-4c11-cb90-e3a03a5914a2"
      },
      "source": [
        "# Mount your google drive (for later model saving & loading)\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OsFX9EkSmXxF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e2439550-8c33-450f-a9ee-dd47d566377f"
      },
      "source": [
        "# DCT modules\n",
        "#print(\"DCT Module:\")\n",
        "#!gdown --id 1MtVZXrFkLTLQgOhFhbYIUrXT-FMKH2hH\n",
        "#from dct import DCT, DFT\n",
        "\n",
        "# download the Weibo dataset\n",
        "!gdown --id 1gjbSZV5NjjIVOqSP-yTCqXcGPX9PnYn5\n",
        "!unzip -q '/content/MM17-WeiboRumorSet.zip'\n",
        "mainfolder = 'MM17-WeiboRumorSet/'\n",
        "subfolders = {'nonrumor_images': 0, 'rumor_images': 1}\n",
        "print(\"Dataset: Weibo is loaded\")\n",
        "\n",
        "# download the Twitter dataset\n",
        "# !gdown --id 1ydEupxLKCmFYe3nfbpbRyCmHi05Oxt5i\n",
        "# !unzip -q '/content/Medieval2015_fake_or_real_Images.zip'\n",
        "# mainfolder = 'Medieval2015_fake_or_real_Images/'\n",
        "# subfolders = {'non-rumor': 0, 'rumor': 1}\n",
        "# print(\"Dataset: Twitter is loaded\")"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading...\n",
            "From: https://drive.google.com/uc?id=1gjbSZV5NjjIVOqSP-yTCqXcGPX9PnYn5\n",
            "To: /content/MM17-WeiboRumorSet.zip\n",
            "1.35GB [00:25, 52.3MB/s]\n",
            "Dataset: Weibo is loaded\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jLz9GPSIgczE"
      },
      "source": [
        "\n",
        "'''\n",
        "Usage:\n",
        "as image preprocessor by calling DCT() as a transform\n",
        "\n",
        "input: 128*128*3 PIL image\n",
        "output: 64*256 torch array (histogram)\n",
        "\n",
        "[128*128] => (crop) => [256 * [8*8]] => (DCT_2d) => [256 * [8 * 8]] => reshape => [256 * 64]  \n",
        "'''\n",
        "\n",
        "class DCT(object):\n",
        "    def __init__(self):\n",
        "        self.BLOCK_HEIGHT = 8\n",
        "        self.BLOCK_WIDTH = 8\n",
        "        self.BLOCK_SIZE = (self.BLOCK_HEIGHT, self.BLOCK_WIDTH)\n",
        "\n",
        "    def div_block(self, img, block_size):\n",
        "        img_height = img.height\n",
        "        img_width = img.width\n",
        "        block_height = block_size[0]\n",
        "        block_width = block_size[1]\n",
        "        assert(img_height % block_height == 0)\n",
        "        assert(img_width % block_width == 0)\n",
        "\n",
        "        blocks = []\n",
        "        for i in range(0,img_height,block_height):\n",
        "            for j in range(0,img_width,block_width):\n",
        "                box = (j, i, j+block_width, i+block_height)\n",
        "                block = np.array(img.crop(box))\n",
        "                blocks.append(block)\n",
        "        return np.array(blocks)\n",
        "\n",
        "    def dct2(self, array_2d):\n",
        "        return dct(dct(array_2d.T, norm = 'ortho').T, norm = 'ortho')\n",
        "\n",
        "    def _dct2(self, array_2d):\n",
        "        return dct(dct(array_2d, norm = 'ortho').T, norm = 'ortho').T\n",
        "\n",
        "    def __call__(self, img):\n",
        "        image = img\n",
        "        blocks = self.div_block(image, self.BLOCK_SIZE)\n",
        "        b_blocks, g_blocks, r_blocks = blocks[:, :, :, 0], blocks[:, :, :, 1], blocks[:, :, :, 2]\n",
        "        test_blocks = (b_blocks + g_blocks + r_blocks) / 3 # naive greyscale\n",
        "        result = np.array([self._dct2(test_block) for test_block in test_blocks])\n",
        "        # return a torch.tensor\n",
        "        return torch.from_numpy(result.reshape(256, 64).T).float()\n",
        "\n",
        "    def __repr__(self):\n",
        "        return \"Simply DCT. What do you expect?\"\n",
        "\n",
        "'''\n",
        "Usage: Same as DCT()\n",
        "\n",
        "input: 64*256 torch array (histogram)\n",
        "output: 64*256 torch array (frequency histogram)\n",
        "'''\n",
        "class DFT(object):\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "    def __call__(self, freq):\n",
        "        # convert into complex form containing real and imaginary part\n",
        "        cmplx = torch.from_numpy(np.zeros((freq.shape[0], freq.shape[1], 2)))\n",
        "        cmplx[:, :, 0] += freq\n",
        "        out = torch.fft(cmplx, 1, normalized=True)[:, :, 0]\n",
        "        return out\n",
        "\n",
        "    def __repr__(self):\n",
        "        return \"Simply DFT. What do you expect?\"\n",
        "\n",
        "\n",
        "'''\n",
        "input: PIL loaded image\n",
        "output: PIL image, in YCbCr color space\n",
        "'''\n",
        "class Ycbcr_convert():\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "    def __call__(self, img):\n",
        "        return img.convert('YCbCr')\n",
        "\n",
        "    def __repr__(self):\n",
        "        return \"Convert a PIL Image from RGB to YCbCr\" "
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ayTY1AY3miLq"
      },
      "source": [
        "## Image transformers for pixel and freq domain"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AeTQn2uZmX2r"
      },
      "source": [
        "## Define the image transformers for pixel and freq domain\n",
        "\n",
        "image_height_pixel, image_width_pixel = 224, 224\n",
        "image_height_freq, image_width_freq = 128, 128\n",
        "tform_pixel = transforms.Compose([\n",
        "    transforms.Resize((image_height_pixel,image_width_pixel), interpolation=Image.BICUBIC),\n",
        "    transforms.ToTensor()\n",
        "])\n",
        "tform_freq = transforms.Compose([\n",
        "    transforms.Resize((image_height_freq,image_width_freq), interpolation=Image.BICUBIC),\n",
        "    Ycbcr_convert(),\n",
        "    DCT(),\n",
        "    # DFT()\n",
        "])\n",
        "\n",
        "def imshow(np_image):\n",
        "    plt.figure(figsize = (5,5))\n",
        "    plt.imshow(np_image) # it should be a numpy array\n",
        "    plt.show()"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4nas4CoTsRqC"
      },
      "source": [
        "### Some remarks from AG  \n",
        "When you use GPU runtime in Colab, apart from the original VM running the notebook, Google will instantiate a new VM with GPU so that parallel computations are forwarded to VM with GPU. \\\\\n",
        "Here we load all the data (~1.35GB, while Nvidia Tesla K80 has 12GB RAM) into memory in the beginning. Hence the data transfer between 2 VMs will only be called once, rather than every mini-batch. This is the point which takes most time, while in the training section later it will exhibit huge speedup."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4sNJgGvkmX5z"
      },
      "source": [
        "class WeiboRumorDataset(Dataset):\n",
        "    def __init__(self, tform_pixel, tform_freq, folder, subfolders):        \n",
        "        self.tform_pixel = tform_pixel\n",
        "        self.tform_freq = tform_freq\n",
        "        self.mainfolder = folder\n",
        "        self.subfolders = subfolders        \n",
        "        self.data = []\n",
        "        # load the entire dataset into memory\n",
        "        for subfolder, label in subfolders.items():\n",
        "            current = os.path.join(self.mainfolder, subfolder)\n",
        "            filenames = os.listdir(current)\n",
        "            for filename in filenames:\n",
        "                self.data.append([os.path.join(subfolder, filename), label])\n",
        "            print(\"[%s]: %d image loaded.\" % (current, len(filenames)))\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.data)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        if torch.is_tensor(idx):\n",
        "            idx = idx.tolist()\n",
        "\n",
        "        filepath, label = self.data[idx]\n",
        "        img = Image.open(os.path.join(self.mainfolder, filepath)).convert('RGB')     \n",
        "        pixel_input = self.tform_pixel(img)\n",
        "        freq_input = self.tform_freq(img)\n",
        "        out = [pixel_input, freq_input, label]\n",
        "        return out"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AxFdeFBD0icA",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 408
        },
        "outputId": "97688376-4660-4b9e-f9d8-ee295e246ae0"
      },
      "source": [
        "# visualize information of the dataset\n",
        "\n",
        "dataset = WeiboRumorDataset(tform_pixel, tform_freq, mainfolder, subfolders)\n",
        "count = dataset.__len__()\n",
        "print('Total no. of images: ', count)\n",
        "\n",
        "pixel_input, freq_input, label = dataset.__getitem__(0)\n",
        "imshow(pixel_input.transpose(0, 1).transpose(1, 2))\n",
        "print(\"Frequency domain shape:\", freq_input.shape)\n",
        "print(\"Label:\", label)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[MM17-WeiboRumorSet/nonrumor_images]: 5318 image loaded.\n",
            "[MM17-WeiboRumorSet/rumor_images]: 7954 image loaded.\n",
            "Total no. of images:  13272\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Frequency domain shape: torch.Size([64, 256])\n",
            "Label: 0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xsxqK2wRlNvD"
      },
      "source": [
        "## Subnetworks"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iSzJzDbwsKAt"
      },
      "source": [
        "class CNN(nn.Module):\n",
        "    def __init__(self, image_height, image_width):\n",
        "        super(CNN, self).__init__()\n",
        "\n",
        "        # NOTE:\n",
        "        # 1. Before each ReLu, a BatchNorm2d layer is added to accelerate convergence (also did by the authors of the paper)\n",
        "\n",
        "        # Conv Model 1\n",
        "        self.conv_M1 = nn.Sequential(nn.Conv2d( 3, 32, 3, padding = 1), nn.BatchNorm2d(32), nn.ReLU(),   # (N,  3, 128, 128) --> (N, 32, 128, 128); add padding = 1 for kernel size = 3 to avoid changing output size\n",
        "                                     nn.Conv2d(32, 32, 1), nn.BatchNorm2d(32), nn.ReLU(),                # (N, 32, 128, 128) --> (N, 32, 128, 128);\n",
        "                                     nn.MaxPool2d(2))                                                    # (N,  3, 128, 128) --> (N, 32,  64,  64);\n",
        "                                     \n",
        "        # Conv Model 2\n",
        "        self.conv_M2 = nn.Sequential(nn.Conv2d(32, 64, 3, padding = 1), nn.BatchNorm2d(64), nn.ReLU(),  # (N, 32, 64, 64) --> (N, 64, 64, 64)\n",
        "                                     nn.Conv2d(64, 64, 1), nn.BatchNorm2d(64), nn.ReLU(),               # (N, 64, 64, 64) --> (N, 64, 64, 64)\n",
        "                                     nn.MaxPool2d(2))                                                   # (N, 64, 64, 64) --> (N, 64, 32, 32)\n",
        "\n",
        "        # Conv Model 3\n",
        "        self.conv_M3 = nn.Sequential(nn.Conv2d(64, 64, 3, padding = 1), nn.BatchNorm2d(64), nn.ReLU(),  # (N, 64, 32, 32) --> (N, 64, 32, 32)\n",
        "                                     nn.Conv2d(64, 64, 1), nn.BatchNorm2d(64), nn.ReLU(),               # (N, 64, 32, 32) --> (N, 64, 32, 32)\n",
        "                                     nn.MaxPool2d(2))                                                   # (N, 64, 32, 32) --> (N, 64, 16, 16)\n",
        "\n",
        "        # Conv Model 4\n",
        "        self.conv_M4 = nn.Sequential(nn.Conv2d( 64, 128, 3, padding = 1), nn.BatchNorm2d(128), nn.ReLU(), # (N,  64, 16, 16) --> (N, 128, 16, 16)\n",
        "                                     nn.Conv2d(128, 128, 1), nn.BatchNorm2d(128), nn.ReLU(),              # (N, 128, 16, 16) --> (N, 128, 16, 16)\n",
        "                                     nn.MaxPool2d(2))                                                     # (N, 128, 16, 16) --> (N, 128,  8,  8)\n",
        "        \n",
        "        #===== For each branch =====%\n",
        "        # Note:\n",
        "        # 1. Flatten convolution layer before FC layer, the input column size = 64 neurons * pooled output size\n",
        "        # 2. Since image_height and image_width are fed from outside, we need to ensure the type to int after division, otherwise gives bugs.\n",
        "        # 3. Need to add a dropout layer with a prob of 0.5 after FC layer (see the reference paper)\n",
        "        # 4. Before each FC layer, a BatchNorm2d layer is added to accelerate convergence\n",
        "\n",
        "        self.conv_br1 = nn.Sequential(nn.Conv2d(32, 64, 1),\n",
        "                                      nn.BatchNorm2d(64),\n",
        "                                      nn.Flatten(1, -1),    # flatten from the 2nd dim (1) to the last dim (-1)\n",
        "                                      nn.Linear(int(64*image_height*image_width/2/2), 64),\n",
        "                                      nn.BatchNorm1d(64),\n",
        "                                      nn.Dropout(0.5))\n",
        "\n",
        "        self.conv_br2 = nn.Sequential(nn.Conv2d(64, 64, 1),\n",
        "                                      nn.BatchNorm2d(64),\n",
        "                                      nn.Flatten(1, -1),              \n",
        "                                      nn.Linear(int(64*image_height*image_width/4/4), 64),\n",
        "                                      nn.BatchNorm1d(64),  \n",
        "                                      nn.Dropout(0.5))\n",
        "\n",
        "        self.conv_br3 = nn.Sequential(nn.Conv2d(64, 64, 1),\n",
        "                                      nn.BatchNorm2d(64),\n",
        "                                      nn.Flatten(1, -1),    \n",
        "                                      nn.Linear(int(64*image_height*image_width/8/8), 64),\n",
        "                                      nn.BatchNorm1d(64),\n",
        "                                      nn.Dropout(0.5))\n",
        "\n",
        "        self.conv_br4 = nn.Sequential(nn.Conv2d(128, 64, 1),\n",
        "                                      nn.BatchNorm2d(64),\n",
        "                                      nn.Flatten(1, -1),              \n",
        "                                      nn.Linear(int(64*image_height*image_width/16/16), 64),\n",
        "                                      nn.BatchNorm1d(64),\n",
        "                                      nn.Dropout(0.5))\n",
        "\n",
        "        # FC layer to 2 classes (fake or real) with Softmax to compute prob along the dimension of concatenated features (64*4 = 256)\n",
        "        self.fc = nn.Sequential(nn.Linear(256, 2),\n",
        "                                nn.Dropout(0.5))    \n",
        "                                        #nn.Softmax(dim=1)) # AG: no need for softmax if we use cross entropy loss function, which will also offer prob.\n",
        "                                                            # Now the loss in the training part converges!!\n",
        "    \n",
        "    def forward(self, x):\n",
        "        out1 = self.conv_M1(x)      # Branch 1\n",
        "        out2 = self.conv_M2(out1)   # Branch 2\n",
        "        out3 = self.conv_M3(out2)   # Branch 3\n",
        "        out4 = self.conv_M4(out3)   # Branch 4\n",
        "        v1 = self.conv_br1(out1)\n",
        "        v2 = self.conv_br2(out2)\n",
        "        v3 = self.conv_br3(out3)\n",
        "        v4 = self.conv_br4(out4)\n",
        "        v_cat = torch.cat((v1, v2, v3, v4), dim=1)\n",
        "        # p = self.fc(v_cat)\n",
        "\n",
        "        # print(\"\\n v1 size:\", v1.shape)\n",
        "        # print(\"\\n v2 size:\", v2.shape)\n",
        "        # print(\"\\n v3 size:\", v3.shape)\n",
        "        # print(\"\\n v4 size:\", v4.shape)\n",
        "        # print(\"\\n v_cat size:\", v_cat.shape)\n",
        "        return v1, v2, v3, v4\n",
        "\n",
        "class CNN_GRU(CNN):\n",
        "    def __init__(self, image_height, image_width):\n",
        "        super(CNN_GRU, self).__init__(image_height, image_width)\n",
        "\n",
        "        # The 4 GRUs in layer 1\n",
        "        self.gru1_1 = nn.GRU(input_size=64, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru2_1 = nn.GRU(input_size=64, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru3_1 = nn.GRU(input_size=64, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru4_1 = nn.GRU(input_size=64, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "\n",
        "        # The 4 GRUs in layer 2\n",
        "        self.gru1_2 = nn.GRU(input_size=32, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru2_2 = nn.GRU(input_size=32, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru3_2 = nn.GRU(input_size=32, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "        self.gru4_2 = nn.GRU(input_size=32, hidden_size=32, num_layers=1, bidirectional=False)\n",
        "\n",
        "        self.relu = nn.ReLU()\n",
        "\n",
        "        self.bn = nn.BatchNorm1d(4*2*32)\n",
        "        self.fc = nn.Sequential(nn.Linear(4*2*32, 2))\n",
        "                                            # nn.LogSoftmax(dim=1)) # AG: no need for softmax if we use cross entropy loss function, which will also offer prob.\n",
        "                                                            # Now the loss in the training part converges!!\n",
        "    def forward(self, x):\n",
        "        v1, v2, v3, v4 = super().forward(x)\n",
        "        \n",
        "        v1 = v1.unsqueeze(0) # add an extra dimension to feed into the gru model (4, 64) --> (1, 4, 64)\n",
        "        v2 = v2.unsqueeze(0)\n",
        "        v3 = v3.unsqueeze(0)\n",
        "        v4 = v4.unsqueeze(0)\n",
        "\n",
        "        # backward GRU (1st layer) which reads from v4 to v1 \n",
        "        out4_layer1, h4_backward = self.gru4_1(v4)                  # --> (1, N, 32)\n",
        "        out3_layer1, h3_backward = self.gru3_1(v3, h4_backward)\n",
        "        out2_layer1, h2_backward = self.gru2_1(v2, h3_backward)\n",
        "        out1_layer1, h1_backward = self.gru1_1(v1, h2_backward)\n",
        "\n",
        "\n",
        "        # forward GRU (2nd layer) which reads from v1 to v4 \n",
        "        out1_layer2, h1_forward = self.gru1_2(h1_backward)          # --> (1, N, 32)\n",
        "        out2_layer2, h2_forward = self.gru2_2(h2_backward, h1_backward)\n",
        "        out3_layer2, h3_forward = self.gru3_2(h3_backward, h2_backward)\n",
        "        out4_layer2, h4_forward = self.gru4_2(h4_backward, h3_backward)\n",
        "\n",
        "        # concatenating the forward hidden state and the backward hidden state along the feature dimension --> (1, N, 64)\n",
        "        L1 = torch.squeeze(torch.cat((h1_forward, h1_backward), dim=2)) # --> (N, 64)\n",
        "        L2 = torch.squeeze(torch.cat((h2_forward, h2_backward), dim=2))\n",
        "        L3 = torch.squeeze(torch.cat((h3_forward, h3_backward), dim=2))\n",
        "        L4 = torch.squeeze(torch.cat((h4_forward, h4_backward), dim=2))\n",
        "\n",
        "        # print(\"\\n L1 size:\", L1.shape)\n",
        "        # print(\"\\n L2 size:\", L2.shape)\n",
        "        # print(\"\\n L3 size:\", L3.shape)\n",
        "        # print(\"\\n L4 size:\", L4.shape)\n",
        "\n",
        "        L_cat = torch.cat((L1, L2, L3, L4), dim=1)    # --> (4, N, 32)\n",
        "        # print(\"\\n L_cat size:\", L_cat.shape)\n",
        "        \n",
        "        # p = self.fc(self.bn(L_cat))\n",
        "\n",
        "        return L1, L2, L3, L4, L_cat\n",
        "\n",
        "class Frequent_Domain_Subnetwork(nn.Module):\n",
        "    def __init__(self):\n",
        "            super(Frequent_Domain_Subnetwork, self).__init__()\n",
        "            self.backbone = nn.Sequential(nn.Conv1d(64, 32, 3, padding=1),\n",
        "                                nn.BatchNorm1d(32),\n",
        "                                nn.ReLU(),\n",
        "                                nn.MaxPool1d(2),\n",
        "                                nn.Conv1d(32, 64, 3, padding=1),\n",
        "                                nn.BatchNorm1d(64),\n",
        "                                nn.ReLU(),\n",
        "                                nn.MaxPool1d(2),\n",
        "                                nn.Conv1d(64, 128, 3, padding=1),\n",
        "                                nn.BatchNorm1d(128),\n",
        "                                nn.ReLU(),\n",
        "                                nn.MaxPool1d(2),\n",
        "                                nn.Flatten(),\n",
        "                                nn.Linear(4096, 64),\n",
        "                                nn.ReLU(),\n",
        "                                nn.Linear(64, 64))\n",
        "            \n",
        "    def forward(self, x):\n",
        "        out = self.backbone.forward(x)\n",
        "        return out    "
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GGtmk4wxn8nb"
      },
      "source": [
        "# Models"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nkgAG_e7terO"
      },
      "source": [
        "#=========== Model 1, full MVNN model\n",
        "class MVNN(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "        # subnetworks\n",
        "        self.pixel_subnet = CNN_GRU(image_height_pixel, image_width_pixel)\n",
        "        self.freq_subnet = Frequent_Domain_Subnetwork()\n",
        "\n",
        "        # attention\n",
        "        self.output_len = 5\n",
        "        self.dimensions = 64\n",
        "        self.v = nn.Parameter(torch.rand(self.dimensions, 1))\n",
        "        self.W = nn.Linear(self.dimensions, self.dimensions)\n",
        "        self.softmax = nn.Softmax(dim=1)\n",
        "        self.tanh = nn.Tanh()\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(self.dimensions, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "        dimensions = self.dimensions\n",
        "        output_len = self.output_len\n",
        "\n",
        "        L1, L2, L3, L4, L_cat = self.pixel_subnet(x_pixel)      \n",
        "        L0 = self.freq_subnet(x_freq)\n",
        "\n",
        "        L_all = torch.stack((L0, L1, L2, L3, L4), dim=1) # Bx5x64\n",
        "        batch_size, output_len, dimensions = L_all.shape\n",
        "        L_all = self.W(L_all.reshape(batch_size * output_len, dimensions))\n",
        "        L_all = L_all.reshape((batch_size, output_len, dimensions))\n",
        "        f = self.tanh(L_all.reshape(batch_size, output_len, dimensions))\n",
        "\n",
        "        # Bx5x64 bmm 1x64x1 => Bx5x1 => Bx5\n",
        "        a = self.softmax(torch.matmul(f, self.v).view(batch_size, -1)) \n",
        "        # Bx1x5 bmm Bx5x64 => Bx1x64 => Bx64\n",
        "        u = torch.bmm(a.unsqueeze(1), L_all).view(batch_size, -1)\n",
        "        out = self.Wc(u) # final output: Bx2\n",
        "        return out        \n",
        "\n",
        "#=========== Model 2, w/o freq\n",
        "class MVNN_wout_freq(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "\n",
        "        # subnetworks\n",
        "        self.pixel_subnet = CNN_GRU(image_height_pixel, image_width_pixel)\n",
        "        # self.freq_subnet = Frequent_Domain_Subnetwork()     \n",
        "\n",
        "        # attention\n",
        "        self.output_len = 5\n",
        "        self.dimensions = 64\n",
        "        self.v = nn.Parameter(torch.rand(self.dimensions, 1))\n",
        "        self.W = nn.Linear(self.dimensions, self.dimensions)\n",
        "        self.softmax = nn.Softmax(dim=1)\n",
        "        self.tanh = nn.Tanh()\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(self.dimensions, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "        dimensions = self.dimensions\n",
        "        output_len = self.output_len\n",
        "\n",
        "        L1, L2, L3, L4, L_cat = self.pixel_subnet(x_pixel)      \n",
        "        # L0 = self.freq_subnet(x_freq)\n",
        "\n",
        "        L_all = torch.stack((L1, L2, L3, L4), dim=1) # Bx4x64\n",
        "        # L_all = torch.stack((L0, L1, L2, L3, L4), dim=1) # Bx5x64\n",
        "\n",
        "        batch_size, output_len, dimensions = L_all.shape\n",
        "        L_all = self.W(L_all.reshape(batch_size * output_len, dimensions))\n",
        "        L_all = L_all.reshape((batch_size, output_len, dimensions))\n",
        "        f = self.tanh(L_all.reshape(batch_size, output_len, dimensions))\n",
        "\n",
        "        # Bx4x64 bmm 1x64x1 => Bx5x1 => Bx5\n",
        "        a = self.softmax(torch.matmul(f, self.v).view(batch_size, -1)) \n",
        "        # Bx1x5 bmm Bx5x64 => Bx1x64 => Bx64\n",
        "        u = torch.bmm(a.unsqueeze(1), L_all).view(batch_size, -1)\n",
        "        out = self.Wc(u) # final output: Bx2\n",
        "        return out      \n",
        "\n",
        "#=========== Model 3, MVNN w/o pixel and attention\n",
        "class MVNN_wout_pixel(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "        # subnetworks\n",
        "        self.freq_subnet = Frequent_Domain_Subnetwork()\n",
        "\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(64, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "\n",
        "        L0 = self.freq_subnet(x_freq)  # Bx64\n",
        "        out = self.Wc(L0) # final output: Bx2\n",
        "        return out\n",
        "\n",
        "\n",
        "#=========== Model 4, full MVNN w/o attention\n",
        "class MVNN_wout_att(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "        # subnetworks\n",
        "        self.pixel_subnet = CNN_GRU(image_height_pixel, image_width_pixel)\n",
        "        self.freq_subnet = Frequent_Domain_Subnetwork()\n",
        "\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(64*5, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "\n",
        "        L1, L2, L3, L4, L_cat = self.pixel_subnet(x_pixel)      \n",
        "        L0 = self.freq_subnet(x_freq)\n",
        "\n",
        "        L_all = torch.cat((L0, L1, L2, L3, L4), dim=1) # Bx320\n",
        "        out = self.Wc(L_all) # final output: Bx2\n",
        "        return out\n",
        "\n",
        "#=========== Model 5, MVNN w/o GRU\n",
        "class MVNN_wout_GRU(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "        # subnetworks\n",
        "        self.pixel_subnet = CNN(image_height_pixel, image_width_pixel) #<-- use CNN instead of CNN_GRU\n",
        "        self.freq_subnet = Frequent_Domain_Subnetwork()\n",
        "\n",
        "        # attention\n",
        "        self.output_len = 5\n",
        "        self.dimensions = 64\n",
        "        self.v = nn.Parameter(torch.rand(self.dimensions, 1))\n",
        "        self.W = nn.Linear(self.dimensions, self.dimensions)\n",
        "        self.softmax = nn.Softmax(dim=1)\n",
        "        self.tanh = nn.Tanh()\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(self.dimensions, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "        dimensions = self.dimensions\n",
        "        output_len = self.output_len\n",
        "\n",
        "        v1, v2, v3, v4 = self.pixel_subnet(x_pixel)      \n",
        "        L0 = self.freq_subnet(x_freq)\n",
        "\n",
        "        L_all = torch.stack((L0, v1, v2, v3, v4), dim=1) # Bx5x64\n",
        "        batch_size, output_len, dimensions = L_all.shape\n",
        "        L_all = self.W(L_all.reshape(batch_size * output_len, dimensions))\n",
        "        L_all = L_all.reshape((batch_size, output_len, dimensions))\n",
        "        f = self.tanh(L_all.reshape(batch_size, output_len, dimensions))\n",
        "\n",
        "        # Bx5x64 bmm 1x64x1 => Bx5x1 => Bx5\n",
        "        a = self.softmax(torch.matmul(f, self.v).view(batch_size, -1)) \n",
        "        # Bx1x5 bmm Bx5x64 => Bx1x64 => Bx64\n",
        "        u = torch.bmm(a.unsqueeze(1), L_all).view(batch_size, -1)\n",
        "        out = self.Wc(u) # final output: Bx2\n",
        "        return out\n",
        "\n",
        "#=========== Model 6, MVNN w/o branches (and GRU)\n",
        "class MVNN_wout_branches(nn.Module):\n",
        "    def __init__(self, image_height_pixel, image_width_pixel):\n",
        "        super().__init__()\n",
        "        # subnetworks\n",
        "        self.pixel_subnet = CNN(image_height_pixel, image_width_pixel) #<-- use CNN instead of CNN_GRU\n",
        "        self.freq_subnet = Frequent_Domain_Subnetwork()\n",
        "\n",
        "        # attention\n",
        "        self.output_len = 2\n",
        "        self.dimensions = 64\n",
        "        self.v = nn.Parameter(torch.rand(self.dimensions, 1))\n",
        "        self.W = nn.Linear(self.dimensions, self.dimensions)\n",
        "        self.softmax = nn.Softmax(dim=1)\n",
        "        self.tanh = nn.Tanh()\n",
        "        # final FC\n",
        "        self.Wc = nn.Linear(self.dimensions, 2)\n",
        "\n",
        "    def forward(self, x_pixel, x_freq):\n",
        "        dimensions = self.dimensions\n",
        "        output_len = self.output_len\n",
        "\n",
        "        _, _, _, v4 = self.pixel_subnet(x_pixel)      \n",
        "        L0 = self.freq_subnet(x_freq)\n",
        "\n",
        "        L_all = torch.stack((L0, v4), dim=1) # Bx2x64\n",
        "        batch_size, output_len, dimensions = L_all.shape\n",
        "        L_all = self.W(L_all.reshape(batch_size * output_len, dimensions))\n",
        "        L_all = L_all.reshape((batch_size, output_len, dimensions))\n",
        "        f = self.tanh(L_all.reshape(batch_size, output_len, dimensions))\n",
        "\n",
        "        # Bx2x64 bmm 1x64x1 => Bx2x1 => Bx2\n",
        "        a = self.softmax(torch.matmul(f, self.v).view(batch_size, -1)) \n",
        "        # Bx1x2 bmm Bx2x64 => Bx1x64 => Bx64\n",
        "        u = torch.bmm(a.unsqueeze(1), L_all).view(batch_size, -1)\n",
        "        out = self.Wc(u) # final output: Bx2\n",
        "        return out  "
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hylOuwUt0mf-"
      },
      "source": [
        "## Metrics for model evaluation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3EdG2-b6Yju4"
      },
      "source": [
        "from sklearn.metrics import accuracy_score # normal accuracy\n",
        "from sklearn.metrics import balanced_accuracy_score # used in case of imbalanced data sets, average of recall, from 0 to 1\n",
        "from sklearn.metrics import confusion_matrix # division of performance on the multilabels\n",
        "from sklearn.metrics import cohen_kappa_score # compares model against random prediction, from -1 to 1\n",
        "from sklearn.metrics import classification_report # for multilabel classification, gives precision, recall, f score, support, more\n",
        "\n",
        "def print_metrics(y_true, y_pred, target_names):\n",
        "    print(\"Accuracy:\", accuracy_score(y_true, y_pred))\n",
        "    print(\"Balanced Accuracy:\" , balanced_accuracy_score(y_true, y_pred))\n",
        "    print(\"Confusion Matrix:\\n\", confusion_matrix(y_true, y_pred))\n",
        "    print(\"Cohen Kappa Score:\", cohen_kappa_score(y_true, y_pred))\n",
        "    print(\"Classification Report:\\n\", classification_report(y_true, y_pred, target_names=target_names))\n",
        "\n",
        "#  function to view one image\n",
        "def image_show(np_image):\n",
        "  plt.figure(figsize = (5,5))\n",
        "  plt.imshow(np_image) # it should be a numpy array\n",
        "  plt.show()\n"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EiV4ggkLHI_o"
      },
      "source": [
        "# Hyper-parameters"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yo68qKXqpUo6"
      },
      "source": [
        "# Hyper-parameters\n",
        "MAX_EPOCH = 300\n",
        "learning_rate = 0.0001 # adopt a small lr to ensure convergence\n",
        "batch_size = 32\n",
        "resumetraining = False\n",
        "\n",
        "print_every = 20\n",
        "test_n_savemodel_every_epoch = 2\n",
        "device = 'cuda'\n",
        "seed_no = 0\n",
        "stop_at_loss = 0.1    #before it was 0.1. But it is not very stable.\n",
        "#================================\n",
        "modelname = 'MVNN'    # Which model to use?\n",
        "#================================"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NvJVbvepOrJA"
      },
      "source": [
        "## Let's Start Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gOea_kRVOwPK"
      },
      "source": [
        "torch.set_deterministic = True\n",
        "torch.manual_seed(seed_no) # set seed for reproducibility (still some randomness, not stable...)\n",
        "\n",
        "if modelname == 'MVNN': # hard-coded\n",
        "  model = MVNN(image_height_pixel, image_width_pixel).to(device)\n",
        "\n",
        "elif modelname == 'MVNN_wout_freq':\n",
        "  model = MVNN_wout_freq(image_height_pixel, image_width_pixel).to(device)\n",
        "\n",
        "elif modelname == 'MVNN_wout_pixel':\n",
        "  model = MVNN_wout_pixel(image_height_pixel, image_width_pixel).to(device)\n",
        "\n",
        "elif modelname == 'MVNN_wout_att':\n",
        "  model = MVNN_wout_att(image_height_pixel, image_width_pixel).to(device)\n",
        "\n",
        "elif modelname == 'MVNN_wout_GRU':\n",
        "  model = MVNN_wout_GRU(image_height_pixel, image_width_pixel).to(device)\n",
        "\n",
        "elif modelname == 'MVNN_wout_branches':\n",
        "  model = MVNN_wout_branches(image_height_pixel, image_width_pixel).to(device)\n",
        "\n",
        "else:\n",
        "  model = []\n",
        "  print(\"Error: the selected model is not available!\")\n",
        "\n",
        "# 80% train, 20% test\n",
        "dataset = WeiboRumorDataset(tform_pixel, tform_freq, mainfolder, subfolders)\n",
        "trainset, testset = torch.utils.data.random_split(dataset, [int(count*0.8), count-int(count*0.8)])\n",
        "print('Total no. of train set images: ', len(trainset))\n",
        "print('Total no. of test set images: ', len(testset))\n",
        "\n",
        "labels = dataset.subfolders # the dataset saves the subfolder's name as the labels\n",
        "classes = list(labels.keys()) # convert dict keys into list\n",
        "print('classes:', classes)\n",
        "\n",
        "# Load training and test sets\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, drop_last=True) \n",
        "# pixel_input, freq_input, label = next(iter(trainloader)) \n",
        "# imshow(pixel_input[1,:,:,:].transpose(0, 1).transpose(1, 2)) # plot figure to check reproduciablility\n",
        "\n",
        "testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=True, drop_last=True) \n",
        "# pixel_input, freq_input, label = next(iter(testloader))\n",
        "# imshow(pixel_input[1,:,:,:].transpose(0, 1).transpose(1, 2)) # plot figure to check reproduciablility\n",
        "\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n",
        "\n",
        "# Resume the last trained model?\n",
        "#================================\n",
        "resume_epoch = 0\n",
        "if resumetraining == True:\n",
        "  # load the model checkpoint\n",
        "  PATH = ('drive/My Drive/Colab Notebooks/trained_models/' + modelname + \"_MAXepoch\" + str(MAX_EPOCH)\n",
        "          + \"_batch\" + str(batch_size) + \"_lr\" + str(learning_rate) + '_seed' + str(seed_no) + \".pth\")\n",
        "  print('Loading from ', PATH)\n",
        "\n",
        "  checkpoint = torch.load(PATH)\n",
        "  # load model weights state_dict\n",
        "  model.load_state_dict(checkpoint['model_state_dict'])\n",
        "  print('Previously trained model weights state_dict loaded...')\n",
        "\n",
        "  # load trained optimizer state_dict\n",
        "  optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n",
        "  print('Previously trained optimizer state_dict loaded...')\n",
        "\n",
        "  resume_epoch = checkpoint['epoch']\n",
        "  # load the criterion\n",
        "  criterion = checkpoint['loss']\n",
        "  print('Trained model loss function loaded...')\n",
        "\n",
        "  # load the acc & loss in the previous epochs\n",
        "  epoch_acc = checkpoint['epoch_acc']\n",
        "  epoch_loss = checkpoint['epoch_loss']\n",
        "\n",
        "  print('\\n===== Resuming the Last Training from Epoch %d ... =====' %(resume_epoch))\n",
        "else:\n",
        "  epoch_acc = []\n",
        "  epoch_loss = []\n",
        "  print('\\n===== Start a New Training ... =====')\n",
        "  \n",
        "\n",
        "for epoch in range(MAX_EPOCH - resume_epoch):\n",
        "    total_loss, total_acc = 0, 0\n",
        "    cnt = 0\n",
        "    t0 = time.time()\n",
        "\n",
        "    epoch = epoch + resume_epoch\n",
        "    for i, data in enumerate(trainloader):\n",
        "\n",
        "        Xp, Xf = data[0].float().to(device), data[1].float().to(device)\n",
        "        y = data[2].to(device)        \n",
        "\n",
        "        optimizer.zero_grad() \n",
        "        \n",
        "        # forward\n",
        "        out = model(Xp, Xf)        \n",
        "        #print(out, y_pred)\n",
        "        loss = criterion(out, y)\n",
        "\n",
        "        # backward\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        # stats\n",
        "        y_pred = torch.argmax(out, dim=1)\n",
        "        total_acc += (y_pred == y).sum().item() / len(y_pred)\n",
        "        total_loss += loss.item()\n",
        "\n",
        "        cnt += 1\n",
        "        if i % print_every == 0:\n",
        "            running_loss = total_loss / cnt\n",
        "            running_acc = total_acc / cnt\n",
        "            # total_acc, total_loss = 0, 0\n",
        "            # cnt = 0\n",
        "            # print(out.T, '\\n', y_pred.T, '\\n', y.T)\n",
        "            print('%s: [Epoch %d] [Iter %d/%d] Running Loss: %5f  Running Acc: %5f' \n",
        "                  %(modelname, epoch+1, i+1, int(len(trainset)/trainloader.batch_size), running_loss, running_acc))\n",
        "\n",
        "    # Store the average acc & loss for each epoch for later plotting\n",
        "    print('Training: Loss = %5f, Acc = %5f' %(running_loss, running_acc))\n",
        "    epoch_acc.append(running_acc)\n",
        "    epoch_loss.append(running_loss)\n",
        "\n",
        "    # Time the training\n",
        "    t1 = time.time()\n",
        "    print(\"Training Time: %10.3f mins\" %((t1-t0)/60))\n",
        "\n",
        "    # Validating\n",
        "    if (epoch+1) % test_n_savemodel_every_epoch == 0:\n",
        "      report_every = 10\n",
        "      test_loss = 0\n",
        "      cnt = 0\n",
        "      model.eval()\n",
        "      y_true = []\n",
        "      y_pred = []\n",
        "      with torch.no_grad():\n",
        "          print('\\n===== Start Validating ... =====')\n",
        "          for data in testloader:\n",
        "              Xp, Xf = data[0].float().to(device), data[1].float().to(device)\n",
        "              y = data[2].to(device)\n",
        "\n",
        "              # prediction\n",
        "              out = model(Xp, Xf)        \n",
        "              pred = torch.argmax(out, dim=1)\n",
        "\n",
        "              loss = criterion(out, y)\n",
        "              test_loss += loss.item()\n",
        "\n",
        "              y_true.append(y)\n",
        "              y_pred.append(pred)\n",
        "\n",
        "              cnt += 1\n",
        "\n",
        "              if cnt % report_every == 0:\n",
        "                  print(\"[Test] [Epoch %d]  %d / %d batches tested\" % (epoch+1, cnt, testloader.__len__()))        \n",
        "\n",
        "          test_loss = test_loss/cnt\n",
        "          print(\"[Test] [Epoch %d] %d / %d batches tested. Test Loss: %5f\" % (epoch+1, cnt, testloader.__len__(), test_loss))\n",
        "      model.train() # Toggle on the training mode to enable back the dropout/batchnorm layers for training\n",
        "      \n",
        "      # Print classification report\n",
        "      y_true = torch.cat(y_true, dim=0)\n",
        "      y_pred = torch.cat(y_pred, dim=0)\n",
        "      target_names = ['non-rumor', 'rumor']\n",
        "      print_metrics(y_true.cpu(), y_pred.cpu(), target_names)\n",
        "      print('')\n",
        "\n",
        "      # Save model checkpoint\n",
        "      PATH = ('drive/My Drive/Colab Notebooks/trained_models/' + modelname + \"_MAXepoch\" + str(MAX_EPOCH)\n",
        "              + \"_batch\" + str(batch_size) + \"_lr\" + str(learning_rate) + '_seed' + str(seed_no) + \".pth\")\n",
        "      print(PATH)\n",
        "      torch.save({\n",
        "            'epoch': epoch+1,\n",
        "            'model_state_dict': model.state_dict(),\n",
        "            'optimizer_state_dict': optimizer.state_dict(),\n",
        "            'loss': criterion,\n",
        "            'epoch_acc': epoch_acc,\n",
        "            'epoch_loss': epoch_loss,\n",
        "            }, PATH)\n",
        "      print('!!! The trained model is saved !!!') # Make sure you have enough space on google drive\n",
        "\n",
        "    # Early stopper\n",
        "    if running_loss < stop_at_loss:\n",
        "      print('Training is stopped at [Epoch %d] as loss is already very low (%5f)!' %(epoch+1, running_loss))\n",
        "      break\n",
        "\n",
        "print('\\n===== Finished Training & Validating =====')\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O6jQUG4hOccu"
      },
      "source": [
        "# Training graph"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jfdMzsbAOcB-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "be54a0e7-cf5d-4c86-dc77-49f3d9a1c42c"
      },
      "source": [
        "x = list(range(1, epoch+2))\n",
        "# print(x)\n",
        "# print(epoch_acc)\n",
        "\n",
        "fig, (ax1, ax2) = plt.subplots(2, 1)\n",
        "fig.suptitle('Training metrics (%s)' %(modelname))    \n",
        "ax1.plot(x, epoch_acc, 'o-')\n",
        "ax1.set_ylabel('Accuracy')\n",
        "ax1.set_xticks(list(range(1, epoch+2, 2)))\n",
        "\n",
        "ax2.plot(x, epoch_loss, '.-')\n",
        "ax2.set_xlabel('Epoch')\n",
        "ax2.set_ylabel('Loss')\n",
        "ax2.set_xticks(list(range(1, epoch+2, 2)))\n",
        "\n",
        "figname = (\"drive/My Drive/Colab Notebooks/trained_models/\"+ modelname + \"_epoch\" + str(epoch+1)\n",
        "         + \"_batch\" + str(batch_size) + \"_lr\" + str(learning_rate) + '_' + 'seed' + str(seed_no) + '_'\n",
        "         + datetime.today().strftime('%Y-%m-%d') + \"v4.pdf\")\n",
        "\n",
        "plt.savefig(figname, bbox_inches='tight')\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gC1SLtQjDXck"
      },
      "source": [
        "# Save the trained model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6ZjCLDm-DWt6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0bf26264-34c6-4011-de3b-835870a5d365"
      },
      "source": [
        "# Specify a path to your local drive\n",
        "PATH = ('drive/My Drive/Colab Notebooks/trained_models/' + modelname + \"_epoch\" + str(epoch+1)\n",
        "         + \"_batch\" + str(batch_size) + \"_lr\" + str(learning_rate) + '_' + 'seed' + str(seed_no) + '_'\n",
        "         + datetime.today().strftime('%Y-%m-%d') + \".pt\")\n",
        "print(PATH)\n",
        "\n",
        "# Save the trained model\n",
        "torch.save(model, PATH)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "drive/My Drive/Colab Notebooks/trained_models/MVNN_wout_freq_epoch5_batch32_lr0.0001_seed0_2020-11-04.pt\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zYR3Z7xgYU18"
      },
      "source": [
        "## Load the trained model from google drive share id"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cpZXxMnBeXbU"
      },
      "source": [
        "# Download the trained full MVNN model\n",
        "# !gdown --id 1-1Io_bGiir9Wq4cgwzkdNrVzseRYX4pa\n",
        "# PATH = '/content/MVNN_epoch16_batch32_lr0.0001_seed0_2020-10-31.pt'\n",
        "\n",
        "# Download the trained MVNN without frequency\n",
        "# !gdown --id 1lAYnZ4OZbivnlkkkzWpc9F6GTLRqpRjO\n",
        "# PATH = '/content/MVNN_wout_freq_epoch19_batch32_lr0.0001_seed0_2020-10-31.pt'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MC2rwHwoYcin"
      },
      "source": [
        "model = torch.load(PATH)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lNsR5NuQYnL3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7cb6fe04-607a-4932-89bf-12d2580fe253"
      },
      "source": [
        "report_every = 10\n",
        "acc, loss = 0, 0\n",
        "cnt = 0\n",
        "model.eval()\n",
        "y_true = []\n",
        "y_pred = []\n",
        "with torch.no_grad():\n",
        "    print('\\n===== Start Validating ... =====')\n",
        "    for data in testloader:\n",
        "        Xp, Xf = data[0].float().to(device), data[1].float().to(device)\n",
        "        y = data[2].to(device)\n",
        "\n",
        "        # prediction\n",
        "        out = model(Xp, Xf)        \n",
        "        pred = torch.argmax(out, dim=1)\n",
        "\n",
        "        y_true.append(y)\n",
        "        y_pred.append(pred)\n",
        "\n",
        "        cnt += 1\n",
        "\n",
        "        if cnt % report_every == 0:\n",
        "            print(\"[Test] %d / %d batches tested\" % (cnt, testloader.__len__()))        \n",
        "\n",
        "    print(\"[Test] %d / %d batches tested\" % (cnt, testloader.__len__()))\n",
        "    y_true = torch.cat(y_true, dim=0)\n",
        "    y_pred = torch.cat(y_pred, dim=0)\n",
        "    target_names = ['non-rumor', 'rumor']\n",
        "    print_metrics(y_true.cpu(), y_pred.cpu(), target_names)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "===== Start Validating ... =====\n",
            "[Test] 10 / 82 batches tested\n",
            "[Test] 20 / 82 batches tested\n",
            "[Test] 30 / 82 batches tested\n",
            "[Test] 40 / 82 batches tested\n",
            "[Test] 50 / 82 batches tested\n",
            "[Test] 60 / 82 batches tested\n",
            "[Test] 70 / 82 batches tested\n",
            "[Test] 80 / 82 batches tested\n",
            "[Test] 82 / 82 batches tested\n",
            "Accuracy: 0.8117378048780488\n",
            "Balanced Accuracy: 0.797647948915823\n",
            "Confusion Matrix:\n",
            " [[ 763  286]\n",
            " [ 208 1367]]\n",
            "Cohen Kappa Score: 0.6027802343746649\n",
            "Classification Report:\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "   non-rumor       0.79      0.73      0.76      1049\n",
            "       rumor       0.83      0.87      0.85      1575\n",
            "\n",
            "    accuracy                           0.81      2624\n",
            "   macro avg       0.81      0.80      0.80      2624\n",
            "weighted avg       0.81      0.81      0.81      2624\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}
